home *** CD-ROM | disk | FTP | other *** search
/ Champak 54 / Vol 54.iso / games / theguard.swf / scripts / DefineSprite_106 / frame_20 / DoAction.as
Encoding:
Text File  |  2007-09-28  |  76.5 KB  |  1,636 lines

  1. var ┬º\x01┬º = 841;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 841)
  6.    {
  7.       set("\x01",eval("\x01") - 499);
  8.       ┬º┬ºpush(true);
  9.       continue;
  10.    }
  11.    if(eval("\x01") == 780)
  12.    {
  13.       set("\x01",eval("\x01") - 688);
  14.       continue;
  15.    }
  16.    if(eval("\x01") == 11)
  17.    {
  18.       set("\x01",eval("\x01") + 497);
  19.       ┬º┬ºpush(true);
  20.       continue;
  21.    }
  22.    if(eval("\x01") == 513)
  23.    {
  24.       set("\x01",eval("\x01") + 380);
  25.       continue;
  26.    }
  27.    if(eval("\x01") == 550)
  28.    {
  29.       set("\x01",eval("\x01") - 257);
  30.       continue;
  31.    }
  32.    if(eval("\x01") == 166)
  33.    {
  34.       set("\x01",eval("\x01") + 347);
  35.       ┬º┬ºpush(┬º┬ºpop() * ┬º┬ºpop());
  36.       break;
  37.    }
  38.    if(eval("\x01") == 676)
  39.    {
  40.       set("\x01",eval("\x01") + 198);
  41.       continue;
  42.    }
  43.    if(eval("\x01") == 901)
  44.    {
  45.       set("\x01",eval("\x01") - 510);
  46.       continue;
  47.    }
  48.    if(eval("\x01") == 25)
  49.    {
  50.       set("\x01",eval("\x01") + 941);
  51.       loop7:
  52.       while(true)
  53.       {
  54.          if(┬º┬ºpop())
  55.          {
  56.             set("\x01",eval("\x01") + 646);
  57.          }
  58.          addr388:
  59.          addr647:
  60.          addr648:
  61.          while(true)
  62.          {
  63.             if(eval("\x01") == 336)
  64.             {
  65.                set("\x01",eval("\x01") + 148);
  66.                ┬º┬ºpush(true);
  67.                continue;
  68.             }
  69.             if(eval("\x01") == 775)
  70.             {
  71.                set("\x01",eval("\x01") - 464);
  72.                break loop0;
  73.             }
  74.             if(eval("\x01") == 655)
  75.             {
  76.                set("\x01",eval("\x01") - 320);
  77.                continue;
  78.             }
  79.             if(eval("\x01") == 919)
  80.             {
  81.                set("\x01",eval("\x01") - 267);
  82.                continue;
  83.             }
  84.             if(eval("\x01") == 18)
  85.             {
  86.                set("\x01",eval("\x01") + 703);
  87.                ┬º┬ºpush(true);
  88.                continue;
  89.             }
  90.             if(eval("\x01") == 273)
  91.             {
  92.                set("\x01",eval("\x01") + 646);
  93.                prevFrame();
  94.                break loop0;
  95.             }
  96.             if(eval("\x01") == 965)
  97.             {
  98.                set("\x01",eval("\x01") - 947);
  99.                continue;
  100.             }
  101.             if(eval("\x01") == 721)
  102.             {
  103.                set("\x01",eval("\x01") + 62);
  104.                if(┬º┬ºpop())
  105.                {
  106.                   set("\x01",eval("\x01") + 118);
  107.                }
  108.                continue;
  109.             }
  110.             if(eval("\x01") == 524)
  111.             {
  112.                set("\x01",eval("\x01") + 251);
  113.                if(┬º┬ºpop())
  114.                {
  115.                   set("\x01",eval("\x01") - 464);
  116.                }
  117.                continue;
  118.             }
  119.             if(eval("\x01") == 335)
  120.             {
  121.                set("\x01",eval("\x01") + 551);
  122.                ┬º┬ºpush(true);
  123.                continue;
  124.             }
  125.             if(eval("\x01") != 783)
  126.             {
  127.                if(eval("\x01") == 652)
  128.                {
  129.                   set("\x01",eval("\x01") - 128);
  130.                   ┬º┬ºpush(true);
  131.                   continue;
  132.                }
  133.                if(eval("\x01") == 26)
  134.                {
  135.                   set("\x01",eval("\x01") + 135);
  136.                   continue;
  137.                }
  138.                if(eval("\x01") == 253)
  139.                {
  140.                   set("\x01",eval("\x01") + 399);
  141.                   continue;
  142.                }
  143.                if(eval("\x01") == 395)
  144.                {
  145.                   set("\x01",eval("\x01") - 377);
  146.                   continue;
  147.                }
  148.                if(eval("\x01") == 488)
  149.                {
  150.                   set("\x01",eval("\x01") - 93);
  151.                   break loop0;
  152.                }
  153.                if(eval("\x01") != 484)
  154.                {
  155.                   break;
  156.                }
  157.                set("\x01",eval("\x01") - 211);
  158.                continue loop7;
  159.             }
  160.             set("\x01",eval("\x01") + 118);
  161.          }
  162.          ┬º┬ºpush("\x01");
  163.          while(true)
  164.          {
  165.             if(eval(┬º┬ºpop()) == 311)
  166.             {
  167.                set("\x01",eval("\x01") + 24);
  168.             }
  169.             else if(eval("\x01") == 886)
  170.             {
  171.                set("\x01",eval("\x01") - 398);
  172.                if(┬º┬ºpop())
  173.                {
  174.                   set("\x01",eval("\x01") - 93);
  175.                }
  176.             }
  177.             else
  178.             {
  179.                if(eval("\x01") != 901)
  180.                {
  181.                   if(eval("\x01") == 161)
  182.                   {
  183.                      set("\x01",eval("\x01") + 584);
  184.                      gotoAndStop(1);
  185.                      break loop0;
  186.                   }
  187.                   if(eval("\x01") == 745)
  188.                   {
  189.                      set("\x01",eval("\x01") - 745);
  190.                   }
  191.                   break loop0;
  192.                }
  193.                set("\x01",eval("\x01") - 740);
  194.             }
  195.             ┬º┬ºgoto(addr388);
  196.             ┬º┬ºgoto(addr647);
  197.          }
  198.       }
  199.    }
  200.    else
  201.    {
  202.       if(eval("\x01") == 633)
  203.       {
  204.          set("\x01",eval("\x01") + 241);
  205.          continue;
  206.       }
  207.       if(eval("\x01") == 893)
  208.       {
  209.          set("\x01",eval("\x01") - 448);
  210.          ┬º┬ºpush(true);
  211.          continue;
  212.       }
  213.       if(eval("\x01") == 696)
  214.       {
  215.          set("\x01",eval("\x01") - 685);
  216.          continue;
  217.       }
  218.       if(eval("\x01") == 634)
  219.       {
  220.          set("\x01",eval("\x01") + 259);
  221.          continue;
  222.       }
  223.       if(eval("\x01") == 493)
  224.       {
  225.          set("\x01",eval("\x01") + 116);
  226.          break;
  227.       }
  228.       if(eval("\x01") == 621)
  229.       {
  230.          set("\x01",eval("\x01") - 230);
  231.          continue;
  232.       }
  233.       if(eval("\x01") == 293)
  234.       {
  235.          set("\x01",eval("\x01") + 697);
  236.          _root.activeCode = null;
  237.          break;
  238.       }
  239.       if(eval("\x01") == 445)
  240.       {
  241.          set("\x01",eval("\x01") + 48);
  242.          if(┬º┬ºpop())
  243.          {
  244.             set("\x01",eval("\x01") + 116);
  245.          }
  246.          continue;
  247.       }
  248.       if(eval("\x01") == 508)
  249.       {
  250.          set("\x01",eval("\x01") + 149);
  251.          if(┬º┬ºpop())
  252.          {
  253.             set("\x01",eval("\x01") - 308);
  254.          }
  255.          continue;
  256.       }
  257.       if(eval("\x01") == 388)
  258.       {
  259.          set("\x01",eval("\x01") + 326);
  260.          if(┬º┬ºpop())
  261.          {
  262.             set("\x01",eval("\x01") - 199);
  263.          }
  264.          continue;
  265.       }
  266.       if(eval("\x01") == 235)
  267.       {
  268.          set("\x01",eval("\x01") + 702);
  269.          continue;
  270.       }
  271.       if(eval("\x01") == 342)
  272.       {
  273.          set("\x01",eval("\x01") - 317);
  274.          if(┬º┬ºpop())
  275.          {
  276.             set("\x01",eval("\x01") + 941);
  277.          }
  278.          continue;
  279.       }
  280.       if(eval("\x01") == 657)
  281.       {
  282.          set("\x01",eval("\x01") - 308);
  283.          ┬º┬ºgoto(addr648);
  284.       }
  285.       else
  286.       {
  287.          if(eval("\x01") == 349)
  288.          {
  289.             set("\x01",eval("\x01") + 24);
  290.             continue;
  291.          }
  292.          if(eval("\x01") == 966)
  293.          {
  294.             set("\x01",eval("\x01") - 874);
  295.             continue;
  296.          }
  297.          if(eval("\x01") == 515)
  298.          {
  299.             set("\x01",eval("\x01") - 97);
  300.             continue;
  301.          }
  302.          if(eval("\x01") == 609)
  303.          {
  304.             set("\x01",eval("\x01") - 555);
  305.             continue;
  306.          }
  307.          if(eval("\x01") == 849)
  308.          {
  309.             set("\x01",eval("\x01") - 476);
  310.             continue;
  311.          }
  312.          if(eval("\x01") == 874)
  313.          {
  314.             set("\x01",eval("\x01") - 223);
  315.             ┬º┬ºpush(true);
  316.             continue;
  317.          }
  318.          if(eval("\x01") == 92)
  319.          {
  320.             set("\x01",eval("\x01") + 503);
  321.             ┬º┬ºpush(true);
  322.             continue;
  323.          }
  324.          if(eval("\x01") == 990)
  325.          {
  326.             set("\x01",eval("\x01") - 990);
  327.             break;
  328.          }
  329.          if(eval("\x01") == 230)
  330.          {
  331.             set("\x01",eval("\x01") + 63);
  332.             continue;
  333.          }
  334.          if(eval("\x01") != 578)
  335.          {
  336.             if(eval("\x01") == 373)
  337.             {
  338.                set("\x01",eval("\x01") + 42);
  339.                ┬º┬ºpush(true);
  340.             }
  341.             else if(eval("\x01") == 415)
  342.             {
  343.                set("\x01",eval("\x01") + 163);
  344.                if(┬º┬ºpop())
  345.                {
  346.                   set("\x01",eval("\x01") + 55);
  347.                }
  348.             }
  349.             else if(eval("\x01") == 651)
  350.             {
  351.                set("\x01",eval("\x01") - 485);
  352.                if(┬º┬ºpop())
  353.                {
  354.                   set("\x01",eval("\x01") + 347);
  355.                }
  356.             }
  357.             else
  358.             {
  359.                if(eval("\x01") == 714)
  360.                {
  361.                   set("\x01",eval("\x01") - 199);
  362.                   break;
  363.                }
  364.                if(eval("\x01") == 976)
  365.                {
  366.                   set("\x01",eval("\x01") - 922);
  367.                }
  368.                else if(eval("\x01") == 54)
  369.                {
  370.                   set("\x01",eval("\x01") + 334);
  371.                   ┬º┬ºpush(true);
  372.                }
  373.                else
  374.                {
  375.                   if(eval("\x01") == 132)
  376.                   {
  377.                      set("\x01",eval("\x01") + 103);
  378.                      ┬º┬ºpush(┬º┬ºpop());
  379.                      break;
  380.                   }
  381.                   if(eval("\x01") == 295)
  382.                   {
  383.                      set("\x01",eval("\x01") - 284);
  384.                   }
  385.                   else
  386.                   {
  387.                      if(eval("\x01") == 378)
  388.                      {
  389.                         set("\x01",eval("\x01") - 83);
  390.                         loop1:
  391.                         while(true)
  392.                         {
  393.                            while(true)
  394.                            {
  395.                               if(eval("\x01") == 703)
  396.                               {
  397.                                  set("\x01",eval("\x01") - 200);
  398.                                  ┬º┬ºpush(true);
  399.                               }
  400.                               else if(eval("\x01") == 746)
  401.                               {
  402.                                  set("\x01",eval("\x01") - 249);
  403.                               }
  404.                               else
  405.                               {
  406.                                  if(eval("\x01") == 735)
  407.                                  {
  408.                                     set("\x01",eval("\x01") - 182);
  409.                                     break loop0;
  410.                                  }
  411.                                  if(eval("\x01") == 91)
  412.                                  {
  413.                                     set("\x01",eval("\x01") + 628);
  414.                                     if(┬º┬ºpop())
  415.                                     {
  416.                                        set("\x01",eval("\x01") - 238);
  417.                                     }
  418.                                  }
  419.                                  else if(eval("\x01") == 130)
  420.                                  {
  421.                                     set("\x01",eval("\x01") - 40);
  422.                                     if(┬º┬ºpop())
  423.                                     {
  424.                                        set("\x01",eval("\x01") + 529);
  425.                                     }
  426.                                  }
  427.                                  else if(eval("\x01") == 644)
  428.                                  {
  429.                                     set("\x01",eval("\x01") - 550);
  430.                                     ┬º┬ºpush(true);
  431.                                  }
  432.                                  else
  433.                                  {
  434.                                     if(eval("\x01") == 410)
  435.                                     {
  436.                                        break loop1;
  437.                                     }
  438.                                     if(eval("\x01") == 992)
  439.                                     {
  440.                                        set("\x01",eval("\x01") - 65);
  441.                                     }
  442.                                     else if(eval("\x01") == 619)
  443.                                     {
  444.                                        set("\x01",eval("\x01") - 496);
  445.                                     }
  446.                                     else if(eval("\x01") == 649)
  447.                                     {
  448.                                        set("\x01",eval("\x01") - 5);
  449.                                     }
  450.                                     else if(eval("\x01") == 497)
  451.                                     {
  452.                                        set("\x01",eval("\x01") + 356);
  453.                                        ┬º┬ºpush(true);
  454.                                     }
  455.                                     else if(eval("\x01") == 695)
  456.                                     {
  457.                                        set("\x01",eval("\x01") + 212);
  458.                                     }
  459.                                     else
  460.                                     {
  461.                                        if(eval("\x01") == 719)
  462.                                        {
  463.                                           set("\x01",eval("\x01") - 238);
  464.                                           break loop0;
  465.                                        }
  466.                                        if(eval("\x01") == 473)
  467.                                        {
  468.                                           set("\x01",eval("\x01") - 343);
  469.                                           ┬º┬ºpush(true);
  470.                                        }
  471.                                        else if(eval("\x01") == 503)
  472.                                        {
  473.                                           set("\x01",eval("\x01") - 287);
  474.                                           if(┬º┬ºpop())
  475.                                           {
  476.                                              set("\x01",eval("\x01") + 354);
  477.                                           }
  478.                                        }
  479.                                        else if(eval("\x01") == 384)
  480.                                        {
  481.                                           set("\x01",eval("\x01") + 311);
  482.                                        }
  483.                                        else if(eval("\x01") == 94)
  484.                                        {
  485.                                           set("\x01",eval("\x01") + 316);
  486.                                           if(┬º┬ºpop())
  487.                                           {
  488.                                              set("\x01",eval("\x01") - 310);
  489.                                           }
  490.                                        }
  491.                                        else if(eval("\x01") == 100)
  492.                                        {
  493.                                           set("\x01",eval("\x01") + 35);
  494.                                        }
  495.                                        else
  496.                                        {
  497.                                           if(eval("\x01") == 216)
  498.                                           {
  499.                                              set("\x01",eval("\x01") + 354);
  500.                                              break loop0;
  501.                                           }
  502.                                           if(eval("\x01") == 553)
  503.                                           {
  504.                                              set("\x01",eval("\x01") - 56);
  505.                                           }
  506.                                           else if(eval("\x01") == 183)
  507.                                           {
  508.                                              set("\x01",eval("\x01") + 552);
  509.                                              if(┬º┬ºpop())
  510.                                              {
  511.                                                 set("\x01",eval("\x01") - 182);
  512.                                              }
  513.                                           }
  514.                                           else
  515.                                           {
  516.                                              if(eval("\x01") == 168)
  517.                                              {
  518.                                                 break;
  519.                                              }
  520.                                              if(eval("\x01") == 135)
  521.                                              {
  522.                                                 set("\x01",eval("\x01") - 44);
  523.                                                 ┬º┬ºpush(true);
  524.                                              }
  525.                                              else
  526.                                              {
  527.                                                 if(eval("\x01") == 609)
  528.                                                 {
  529.                                                    set("\x01",eval("\x01") + 383);
  530.                                                    break loop0;
  531.                                                 }
  532.                                                 if(eval("\x01") == 907)
  533.                                                 {
  534.                                                    set("\x01",eval("\x01") - 775);
  535.                                                    eval("▀¿\nG")["a{invalid_utf8=181}\x11╘ú═ú"]["\x12{invalid_utf8=200}"]("!l{invalid_utf8=223}\x05\x17{invalid_utf8=229}5");
  536.                                                    eval("▀¿\nG")[┬º┬ºconstant(6)](┬º┬ºconstant(5),"{invalid_utf8=195}{invalid_utf8=254}<{invalid_utf8=164}\x03\x1c\x02");
  537.                                                    gotoAndStop("Start");
  538.                                                    play();
  539.                                                    break loop0;
  540.                                                 }
  541.                                                 if(eval("\x01") == 570)
  542.                                                 {
  543.                                                    set("\x01",eval("\x01") + 74);
  544.                                                 }
  545.                                                 else
  546.                                                 {
  547.                                                    if(eval("\x01") == 95)
  548.                                                    {
  549.                                                       set("\x01",eval("\x01") + 240);
  550.                                                       break loop0;
  551.                                                    }
  552.                                                    if(eval("\x01") == 481)
  553.                                                    {
  554.                                                       set("\x01",eval("\x01") - 8);
  555.                                                    }
  556.                                                    else if(eval("\x01") == 123)
  557.                                                    {
  558.                                                       set("\x01",eval("\x01") + 207);
  559.                                                       ┬º┬ºpush(true);
  560.                                                    }
  561.                                                    else if(eval("\x01") == 835)
  562.                                                    {
  563.                                                       set("\x01",eval("\x01") + 92);
  564.                                                    }
  565.                                                    else
  566.                                                    {
  567.                                                       if(eval("\x01") == 90)
  568.                                                       {
  569.                                                          set("\x01",eval("\x01") + 529);
  570.                                                          loop3:
  571.                                                          while(true)
  572.                                                          {
  573.                                                             set(┬º┬ºpop(),┬º┬ºpop());
  574.                                                             if(┬º┬ºpop())
  575.                                                             {
  576.                                                                set("\x01",eval("\x01") + 659);
  577.                                                             }
  578.                                                             while(true)
  579.                                                             {
  580.                                                                if(eval("\x01") == 504)
  581.                                                                {
  582.                                                                   set("\x01",eval("\x01") + 247);
  583.                                                                   ┬º┬ºpush(true);
  584.                                                                }
  585.                                                                else
  586.                                                                {
  587.                                                                   if(eval("\x01") == 736)
  588.                                                                   {
  589.                                                                      set("\x01",eval("\x01") + 162);
  590.                                                                      stop();
  591.                                                                      break loop0;
  592.                                                                   }
  593.                                                                   if(eval("\x01") == 195)
  594.                                                                   {
  595.                                                                      set("\x01",eval("\x01") - 37);
  596.                                                                      ┬º┬ºpush(true);
  597.                                                                   }
  598.                                                                   else if(eval("\x01") == 751)
  599.                                                                   {
  600.                                                                      set("\x01",eval("\x01") - 15);
  601.                                                                      if(┬º┬ºpop())
  602.                                                                      {
  603.                                                                         set("\x01",eval("\x01") + 162);
  604.                                                                      }
  605.                                                                   }
  606.                                                                   else if(eval("\x01") == 45)
  607.                                                                   {
  608.                                                                      set("\x01",eval("\x01") + 560);
  609.                                                                   }
  610.                                                                   else if(eval("\x01") == 482)
  611.                                                                   {
  612.                                                                      set("\x01",eval("\x01") - 192);
  613.                                                                   }
  614.                                                                   else if(eval("\x01") == 768)
  615.                                                                   {
  616.                                                                      set("\x01",eval("\x01") - 83);
  617.                                                                   }
  618.                                                                   else if(eval("\x01") == 158)
  619.                                                                   {
  620.                                                                      set("\x01",eval("\x01") + 539);
  621.                                                                      if(┬º┬ºpop())
  622.                                                                      {
  623.                                                                         set("\x01",eval("\x01") - 259);
  624.                                                                      }
  625.                                                                   }
  626.                                                                   else if(eval("\x01") == 905)
  627.                                                                   {
  628.                                                                      set("\x01",eval("\x01") - 168);
  629.                                                                   }
  630.                                                                   else if(eval("\x01") == 898)
  631.                                                                   {
  632.                                                                      set("\x01",eval("\x01") - 703);
  633.                                                                   }
  634.                                                                   else if(eval("\x01") == 842)
  635.                                                                   {
  636.                                                                      set("\x01",eval("\x01") - 105);
  637.                                                                   }
  638.                                                                   else if(eval("\x01") == 400)
  639.                                                                   {
  640.                                                                      set("\x01",eval("\x01") + 205);
  641.                                                                   }
  642.                                                                   else if(eval("\x01") == 518)
  643.                                                                   {
  644.                                                                      set("\x01",eval("\x01") - 323);
  645.                                                                   }
  646.                                                                   else if(eval("\x01") == 737)
  647.                                                                   {
  648.                                                                      set("\x01",eval("\x01") - 327);
  649.                                                                      ┬º┬ºpush(true);
  650.                                                                   }
  651.                                                                   else
  652.                                                                   {
  653.                                                                      if(eval("\x01") == 615)
  654.                                                                      {
  655.                                                                         break;
  656.                                                                      }
  657.                                                                      if(eval("\x01") == 697)
  658.                                                                      {
  659.                                                                         break loop3;
  660.                                                                      }
  661.                                                                      if(eval("\x01") == 494)
  662.                                                                      {
  663.                                                                         set("\x01",eval("\x01") - 204);
  664.                                                                      }
  665.                                                                      else if(eval("\x01") == 438)
  666.                                                                      {
  667.                                                                         set("\x01",eval("\x01") + 247);
  668.                                                                      }
  669.                                                                      else if(eval("\x01") == 685)
  670.                                                                      {
  671.                                                                         set("\x01",eval("\x01") - 70);
  672.                                                                         ┬º┬ºpush(true);
  673.                                                                      }
  674.                                                                      else
  675.                                                                      {
  676.                                                                         if(eval("\x01") == 605)
  677.                                                                         {
  678.                                                                            set("\x01",eval("\x01") - 28);
  679.                                                                            gotoAndStop(1);
  680.                                                                            break loop0;
  681.                                                                         }
  682.                                                                         if(eval("\x01") == 290)
  683.                                                                         {
  684.                                                                            set("\x01",eval("\x01") + 276);
  685.                                                                            ┬º┬ºpush(true);
  686.                                                                         }
  687.                                                                         else
  688.                                                                         {
  689.                                                                            if(eval("\x01") == 246)
  690.                                                                            {
  691.                                                                               set("\x01",eval("\x01") + 659);
  692.                                                                               break loop0;
  693.                                                                            }
  694.                                                                            if(eval("\x01") == 566)
  695.                                                                            {
  696.                                                                               set("\x01",eval("\x01") + 396);
  697.                                                                               if(┬º┬ºpop())
  698.                                                                               {
  699.                                                                                  set("\x01",eval("\x01") - 562);
  700.                                                                               }
  701.                                                                            }
  702.                                                                            else
  703.                                                                            {
  704.                                                                               if(eval("\x01") == 885)
  705.                                                                               {
  706.                                                                                  set("\x01",eval("\x01") - 391);
  707.                                                                                  break loop0;
  708.                                                                               }
  709.                                                                               if(eval("\x01") == 962)
  710.                                                                               {
  711.                                                                                  set("\x01",eval("\x01") - 562);
  712.                                                                                  break loop0;
  713.                                                                               }
  714.                                                                               if(eval("\x01") != 410)
  715.                                                                               {
  716.                                                                                  if(eval("\x01") == 577)
  717.                                                                                  {
  718.                                                                                     set("\x01",eval("\x01") - 577);
  719.                                                                                  }
  720.                                                                                  break loop0;
  721.                                                                               }
  722.                                                                               set("\x01",eval("\x01") + 475);
  723.                                                                               if(┬º┬ºpop())
  724.                                                                               {
  725.                                                                                  set("\x01",eval("\x01") - 391);
  726.                                                                               }
  727.                                                                            }
  728.                                                                         }
  729.                                                                      }
  730.                                                                   }
  731.                                                                }
  732.                                                             }
  733.                                                          }
  734.                                                          set("\x01",eval("\x01") - 259);
  735.                                                          ┬º┬ºpush(┬º┬ºpop() + ┬º┬ºpop());
  736.                                                          break loop0;
  737.                                                       }
  738.                                                       if(eval("\x01") == 567)
  739.                                                       {
  740.                                                          set("\x01",eval("\x01") - 94);
  741.                                                       }
  742.                                                       else if(eval("\x01") == 927)
  743.                                                       {
  744.                                                          set("\x01",eval("\x01") - 744);
  745.                                                          ┬º┬ºpush(true);
  746.                                                       }
  747.                                                       else if(eval("\x01") == 928)
  748.                                                       {
  749.                                                          set("\x01",eval("\x01") - 805);
  750.                                                       }
  751.                                                       else if(eval("\x01") == 853)
  752.                                                       {
  753.                                                          set("\x01",eval("\x01") - 758);
  754.                                                          if(┬º┬ºpop())
  755.                                                          {
  756.                                                             set("\x01",eval("\x01") + 240);
  757.                                                          }
  758.                                                       }
  759.                                                       else if(eval("\x01") == 330)
  760.                                                       {
  761.                                                          set("\x01",eval("\x01") + 279);
  762.                                                          if(┬º┬ºpop())
  763.                                                          {
  764.                                                             set("\x01",eval("\x01") + 383);
  765.                                                          }
  766.                                                       }
  767.                                                       else
  768.                                                       {
  769.                                                          if(eval("\x01") != 335)
  770.                                                          {
  771.                                                             if(eval("\x01") == 132)
  772.                                                             {
  773.                                                                set("\x01",eval("\x01") - 132);
  774.                                                             }
  775.                                                             break loop0;
  776.                                                          }
  777.                                                          set("\x01",eval("\x01") + 360);
  778.                                                       }
  779.                                                    }
  780.                                                 }
  781.                                              }
  782.                                           }
  783.                                        }
  784.                                     }
  785.                                  }
  786.                               }
  787.                            }
  788.                            set("\x01",eval("\x01") - 33);
  789.                         }
  790.                         set("\x01",eval("\x01") - 310);
  791.                         break;
  792.                      }
  793.                      if(eval("\x01") == 77)
  794.                      {
  795.                         set("\x01",eval("\x01") + 341);
  796.                      }
  797.                      else if(eval("\x01") == 662)
  798.                      {
  799.                         set("\x01",eval("\x01") + 275);
  800.                      }
  801.                      else if(eval("\x01") == 97)
  802.                      {
  803.                         set("\x01",eval("\x01") + 35);
  804.                         if(┬º┬ºpop())
  805.                         {
  806.                            set("\x01",eval("\x01") + 103);
  807.                         }
  808.                      }
  809.                      else if(eval("\x01") == 418)
  810.                      {
  811.                         set("\x01",eval("\x01") + 329);
  812.                         ┬º┬ºpush(true);
  813.                      }
  814.                      else if(eval("\x01") == 220)
  815.                      {
  816.                         set("\x01",eval("\x01") + 158);
  817.                         if(┬º┬ºpop())
  818.                         {
  819.                            set("\x01",eval("\x01") - 83);
  820.                         }
  821.                      }
  822.                      else if(eval("\x01") == 595)
  823.                      {
  824.                         set("\x01",eval("\x01") + 25);
  825.                         if(┬º┬ºpop())
  826.                         {
  827.                            set("\x01",eval("\x01") + 1);
  828.                         }
  829.                      }
  830.                      else if(eval("\x01") == 747)
  831.                      {
  832.                         set("\x01",eval("\x01") - 40);
  833.                         if(┬º┬ºpop())
  834.                         {
  835.                            set("\x01",eval("\x01") - 477);
  836.                         }
  837.                      }
  838.                      else
  839.                      {
  840.                         if(eval("\x01") == 707)
  841.                         {
  842.                            set("\x01",eval("\x01") - 477);
  843.                            break;
  844.                         }
  845.                         if(eval("\x01") == 937)
  846.                         {
  847.                            set("\x01",eval("\x01") - 717);
  848.                            ┬º┬ºpush(true);
  849.                         }
  850.                         else
  851.                         {
  852.                            if(eval("\x01") != 391)
  853.                            {
  854.                               if(eval("\x01") == 620)
  855.                               {
  856.                                  set("\x01",eval("\x01") + 1);
  857.                                  ┬º┬ºpush(┬º┬ºpop() % ┬º┬ºpop());
  858.                               }
  859.                               break;
  860.                            }
  861.                            set("\x01",eval("\x01") - 294);
  862.                            ┬º┬ºpush(true);
  863.                         }
  864.                      }
  865.                   }
  866.                }
  867.             }
  868.             continue;
  869.          }
  870.          set("\x01",eval("\x01") + 55);
  871.          while(true)
  872.          {
  873.             if(┬º┬ºpop())
  874.             {
  875.                set("\x01",eval("\x01") + 500);
  876.                ┬º┬ºpush(true);
  877.             }
  878.             else if(eval("\x01") == 143)
  879.             {
  880.                set("\x01",eval("\x01") + 847);
  881.             }
  882.             else if(eval("\x01") == 51)
  883.             {
  884.                set("\x01",eval("\x01") + 418);
  885.             }
  886.             else if(eval("\x01") == 252)
  887.             {
  888.                set("\x01",eval("\x01") + 315);
  889.                if(┬º┬ºpop())
  890.                {
  891.                   set("\x01",eval("\x01") - 466);
  892.                }
  893.             }
  894.             else if(eval("\x01") == 253)
  895.             {
  896.                set("\x01",eval("\x01") + 445);
  897.                if(┬º┬ºpop())
  898.                {
  899.                   set("\x01",eval("\x01") - 2);
  900.                }
  901.             }
  902.             else if(eval("\x01") == 75)
  903.             {
  904.                set("\x01",eval("\x01") + 828);
  905.             }
  906.             else if(eval("\x01") == 886)
  907.             {
  908.                set("\x01",eval("\x01") - 611);
  909.                if(┬º┬ºpop())
  910.                {
  911.                   set("\x01",eval("\x01") + 306);
  912.                }
  913.             }
  914.             else if(eval("\x01") == 756)
  915.             {
  916.                set("\x01",eval("\x01") - 678);
  917.                if(┬º┬ºpop())
  918.                {
  919.                   set("\x01",eval("\x01") + 873);
  920.                }
  921.             }
  922.             else if(eval("\x01") == 989)
  923.             {
  924.                set("\x01",eval("\x01") - 233);
  925.                ┬º┬ºpush(true);
  926.             }
  927.             else if(eval("\x01") == 403)
  928.             {
  929.                set("\x01",eval("\x01") + 586);
  930.             }
  931.             else if(eval("\x01") == 866)
  932.             {
  933.                set("\x01",eval("\x01") + 123);
  934.             }
  935.             else
  936.             {
  937.                if(eval("\x01") != 614)
  938.                {
  939.                   if(eval("\x01") == 377)
  940.                   {
  941.                      set("\x01",eval("\x01") - 377);
  942.                   }
  943.                   break loop0;
  944.                }
  945.                set("\x01",eval("\x01") - 522);
  946.             }
  947.             while(true)
  948.             {
  949.                if(eval("\x01") == 316)
  950.                {
  951.                   set("\x01",eval("\x01") + 573);
  952.                   ┬º┬ºpush(true);
  953.                }
  954.                else
  955.                {
  956.                   if(eval("\x01") == 137)
  957.                   {
  958.                      set("\x01",eval("\x01") + 723);
  959.                      ┬º┬ºpush(┬º┬ºpop() eq ┬º┬ºpop());
  960.                      break loop0;
  961.                   }
  962.                   if(eval("\x01") == 246)
  963.                   {
  964.                      set("\x01",eval("\x01") + 351);
  965.                      if(┬º┬ºpop())
  966.                      {
  967.                         set("\x01",eval("\x01") - 331);
  968.                      }
  969.                   }
  970.                   else
  971.                   {
  972.                      if(eval("\x01") == 275)
  973.                      {
  974.                         set("\x01",eval("\x01") + 306);
  975.                         stopAllSounds();
  976.                         break loop0;
  977.                      }
  978.                      if(eval("\x01") != 641)
  979.                      {
  980.                         if(eval("\x01") == 78)
  981.                         {
  982.                            set("\x01",eval("\x01") + 873);
  983.                            loop10:
  984.                            while(true)
  985.                            {
  986.                               set(┬º┬ºpop(),┬º┬ºpop() + 195);
  987.                               ┬º┬ºpush(true);
  988.                               while(true)
  989.                               {
  990.                                  if(eval("\x01") == 387)
  991.                                  {
  992.                                     set("\x01",eval("\x01") - 247);
  993.                                     ┬º┬ºpush(true);
  994.                                     continue;
  995.                                  }
  996.                                  if(eval("\x01") == 129)
  997.                                  {
  998.                                     set("\x01",eval("\x01") + 682);
  999.                                     stop();
  1000.                                     ┬º┬ºpush(┬º┬ºpop()());
  1001.                                     break loop0;
  1002.                                  }
  1003.                                  if(eval("\x01") == 882)
  1004.                                  {
  1005.                                     set("\x01",eval("\x01") - 25);
  1006.                                     continue;
  1007.                                  }
  1008.                                  if(eval("\x01") == 320)
  1009.                                  {
  1010.                                     set("\x01",eval("\x01") + 160);
  1011.                                     break loop0;
  1012.                                  }
  1013.                                  if(eval("\x01") == 190)
  1014.                                  {
  1015.                                     set("\x01",eval("\x01") + 447);
  1016.                                     ┬º┬ºpush(true);
  1017.                                     continue;
  1018.                                  }
  1019.                                  if(eval("\x01") == 590)
  1020.                                  {
  1021.                                     set("\x01",eval("\x01") - 4);
  1022.                                     if(┬º┬ºpop())
  1023.                                     {
  1024.                                        set("\x01",eval("\x01") + 296);
  1025.                                     }
  1026.                                     continue;
  1027.                                  }
  1028.                                  if(eval("\x01") == 241)
  1029.                                  {
  1030.                                     set("\x01",eval("\x01") + 349);
  1031.                                     ┬º┬ºpush(true);
  1032.                                     continue;
  1033.                                  }
  1034.                                  if(eval("\x01") == 784)
  1035.                                  {
  1036.                                     set("\x01",eval("\x01") + 183);
  1037.                                     continue;
  1038.                                  }
  1039.                                  if(eval("\x01") == 857)
  1040.                                  {
  1041.                                     set("\x01",eval("\x01") - 568);
  1042.                                     continue;
  1043.                                  }
  1044.                                  if(eval("\x01") == 140)
  1045.                                  {
  1046.                                     set("\x01",eval("\x01") + 319);
  1047.                                     if(┬º┬ºpop())
  1048.                                     {
  1049.                                        set("\x01",eval("\x01") + 413);
  1050.                                     }
  1051.                                     continue;
  1052.                                  }
  1053.                                  if(eval("\x01") == 586)
  1054.                                  {
  1055.                                     set("\x01",eval("\x01") + 296);
  1056.                                     prevFrame();
  1057.                                     break loop0;
  1058.                                  }
  1059.                                  if(eval("\x01") == 456)
  1060.                                  {
  1061.                                     set("\x01",eval("\x01") + 503);
  1062.                                     if(┬º┬ºpop())
  1063.                                     {
  1064.                                        set("\x01",eval("\x01") - 927);
  1065.                                     }
  1066.                                     continue;
  1067.                                  }
  1068.                                  if(eval("\x01") == 270)
  1069.                                  {
  1070.                                     set("\x01",eval("\x01") - 9);
  1071.                                     continue;
  1072.                                  }
  1073.                                  if(eval("\x01") == 282)
  1074.                                  {
  1075.                                     set("\x01",eval("\x01") + 191);
  1076.                                     ┬º┬ºpush(┬º┬ºpop() - 1);
  1077.                                     break loop0;
  1078.                                  }
  1079.                                  if(eval("\x01") == 811)
  1080.                                  {
  1081.                                     set("\x01",eval("\x01") - 621);
  1082.                                     continue;
  1083.                                  }
  1084.                                  if(eval("\x01") == 647)
  1085.                                  {
  1086.                                     set("\x01",eval("\x01") - 369);
  1087.                                     continue;
  1088.                                  }
  1089.                                  if(eval("\x01") == 399)
  1090.                                  {
  1091.                                     set("\x01",eval("\x01") - 158);
  1092.                                     continue;
  1093.                                  }
  1094.                                  if(eval("\x01") == 278)
  1095.                                  {
  1096.                                     set("\x01",eval("\x01") + 688);
  1097.                                     ┬º┬ºpush(true);
  1098.                                     continue;
  1099.                                  }
  1100.                                  if(eval("\x01") == 591)
  1101.                                  {
  1102.                                     set("\x01",eval("\x01") - 86);
  1103.                                     continue;
  1104.                                  }
  1105.                                  if(eval("\x01") == 436)
  1106.                                  {
  1107.                                     set("\x01",eval("\x01") + 202);
  1108.                                     continue;
  1109.                                  }
  1110.                                  if(eval("\x01") == 977)
  1111.                                  {
  1112.                                     set("\x01",eval("\x01") - 699);
  1113.                                     continue;
  1114.                                  }
  1115.                                  if(eval("\x01") == 135)
  1116.                                  {
  1117.                                     set("\x01",eval("\x01") + 503);
  1118.                                     continue;
  1119.                                  }
  1120.                                  if(eval("\x01") == 473)
  1121.                                  {
  1122.                                     set("\x01",eval("\x01") - 212);
  1123.                                     continue;
  1124.                                  }
  1125.                                  if(eval("\x01") == 480)
  1126.                                  {
  1127.                                     set("\x01",eval("\x01") + 487);
  1128.                                     continue;
  1129.                                  }
  1130.                                  if(eval("\x01") == 637)
  1131.                                  {
  1132.                                     set("\x01",eval("\x01") - 317);
  1133.                                     if(┬º┬ºpop())
  1134.                                     {
  1135.                                        set("\x01",eval("\x01") + 160);
  1136.                                     }
  1137.                                     continue;
  1138.                                  }
  1139.                                  if(eval("\x01") == 204)
  1140.                                  {
  1141.                                     set("\x01",eval("\x01") + 466);
  1142.                                     ┬º┬ºpush(true);
  1143.                                     continue;
  1144.                                  }
  1145.                                  if(eval("\x01") == 216)
  1146.                                  {
  1147.                                     set("\x01",eval("\x01") - 81);
  1148.                                     break loop0;
  1149.                                  }
  1150.                                  if(eval("\x01") == 959)
  1151.                                  {
  1152.                                     set("\x01",eval("\x01") - 927);
  1153.                                     break loop0;
  1154.                                  }
  1155.                                  if(eval("\x01") == 872)
  1156.                                  {
  1157.                                     set("\x01",eval("\x01") - 367);
  1158.                                     continue;
  1159.                                  }
  1160.                                  if(eval("\x01") == 670)
  1161.                                  {
  1162.                                     set("\x01",eval("\x01") - 468);
  1163.                                     if(┬º┬ºpop())
  1164.                                     {
  1165.                                        set("\x01",eval("\x01") + 445);
  1166.                                     }
  1167.                                     continue;
  1168.                                  }
  1169.                                  if(eval("\x01") == 32)
  1170.                                  {
  1171.                                     set("\x01",eval("\x01") + 172);
  1172.                                     continue;
  1173.                                  }
  1174.                                  if(eval("\x01") == 938)
  1175.                                  {
  1176.                                     set("\x01",eval("\x01") - 734);
  1177.                                     continue;
  1178.                                  }
  1179.                                  if(eval("\x01") == 477)
  1180.                                  {
  1181.                                     set("\x01",eval("\x01") + 380);
  1182.                                     continue;
  1183.                                  }
  1184.                                  if(eval("\x01") == 505)
  1185.                                  {
  1186.                                     set("\x01",eval("\x01") - 377);
  1187.                                     ┬º┬ºpush(true);
  1188.                                     continue;
  1189.                                  }
  1190.                                  if(eval("\x01") == 128)
  1191.                                  {
  1192.                                     set("\x01",eval("\x01") + 1);
  1193.                                     if(┬º┬ºpop())
  1194.                                     {
  1195.                                        set("\x01",eval("\x01") + 682);
  1196.                                     }
  1197.                                     continue;
  1198.                                  }
  1199.                                  if(eval("\x01") == 277)
  1200.                                  {
  1201.                                     set("\x01",eval("\x01") - 87);
  1202.                                     continue;
  1203.                                  }
  1204.                                  if(eval("\x01") == 459)
  1205.                                  {
  1206.                                     set("\x01",eval("\x01") + 413);
  1207.                                     ifFrameLoaded(3)
  1208.                                     {
  1209.                                     }
  1210.                                     ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop();
  1211.                                     break loop0;
  1212.                                  }
  1213.                                  if(eval("\x01") == 638)
  1214.                                  {
  1215.                                     set("\x01",eval("\x01") - 495);
  1216.                                     ┬º┬ºpush(true);
  1217.                                     continue;
  1218.                                  }
  1219.                                  if(eval("\x01") == 967)
  1220.                                  {
  1221.                                     set("\x01",eval("\x01") - 894);
  1222.                                     ┬º┬ºpush(true);
  1223.                                     continue;
  1224.                                  }
  1225.                                  if(eval("\x01") == 261)
  1226.                                  {
  1227.                                     break;
  1228.                                  }
  1229.                                  if(eval("\x01") == 73)
  1230.                                  {
  1231.                                     set("\x01",eval("\x01") + 209);
  1232.                                     if(┬º┬ºpop())
  1233.                                     {
  1234.                                        set("\x01",eval("\x01") + 191);
  1235.                                     }
  1236.                                     continue;
  1237.                                  }
  1238.                                  if(eval("\x01") == 202)
  1239.                                  {
  1240.                                     break loop10;
  1241.                                  }
  1242.                                  if(eval("\x01") == 966)
  1243.                                  {
  1244.                                     set("\x01",eval("\x01") - 750);
  1245.                                     if(┬º┬ºpop())
  1246.                                     {
  1247.                                        set("\x01",eval("\x01") - 81);
  1248.                                     }
  1249.                                     continue;
  1250.                                  }
  1251.                                  if(eval("\x01") == 143)
  1252.                                  {
  1253.                                     set("\x01",eval("\x01") + 418);
  1254.                                     if(┬º┬ºpop())
  1255.                                     {
  1256.                                        set("\x01",eval("\x01") - 263);
  1257.                                     }
  1258.                                     continue;
  1259.                                  }
  1260.                                  if(eval("\x01") == 561)
  1261.                                  {
  1262.                                     set("\x01",eval("\x01") - 263);
  1263.                                     while(true)
  1264.                                     {
  1265.                                        if(eval(┬º┬ºpop()) == 721)
  1266.                                        {
  1267.                                           set("\x01",eval("\x01") - 417);
  1268.                                        }
  1269.                                        else
  1270.                                        {
  1271.                                           if(eval("\x01") != 793)
  1272.                                           {
  1273.                                              addr338:
  1274.                                              if(eval("\x01") == 138)
  1275.                                              {
  1276.                                                 set("\x01",eval("\x01") + 583);
  1277.                                                 ┬º┬ºpush(┬º┬ºpop() add ┬º┬ºpop());
  1278.                                                 break loop0;
  1279.                                              }
  1280.                                              if(eval("\x01") == 277)
  1281.                                              {
  1282.                                                 set("\x01",eval("\x01") - 277);
  1283.                                              }
  1284.                                              break loop0;
  1285.                                           }
  1286.                                           set("\x01",eval("\x01") - 655);
  1287.                                           if(┬º┬ºpop())
  1288.                                           {
  1289.                                              set("\x01",eval("\x01") + 583);
  1290.                                           }
  1291.                                        }
  1292.                                        while(true)
  1293.                                        {
  1294.                                           if(eval("\x01") == 586)
  1295.                                           {
  1296.                                              set("\x01",eval("\x01") + 98);
  1297.                                              ┬º┬ºpush(true);
  1298.                                           }
  1299.                                           else if(eval("\x01") == 614)
  1300.                                           {
  1301.                                              set("\x01",eval("\x01") - 35);
  1302.                                              if(┬º┬ºpop())
  1303.                                              {
  1304.                                                 set("\x01",eval("\x01") - 320);
  1305.                                              }
  1306.                                           }
  1307.                                           else if(eval("\x01") == 282)
  1308.                                           {
  1309.                                              set("\x01",eval("\x01") + 555);
  1310.                                           }
  1311.                                           else if(eval("\x01") == 814)
  1312.                                           {
  1313.                                              set("\x01",eval("\x01") + 54);
  1314.                                              if(┬º┬ºpop())
  1315.                                              {
  1316.                                                 set("\x01",eval("\x01") - 170);
  1317.                                              }
  1318.                                           }
  1319.                                           else if(eval("\x01") == 103)
  1320.                                           {
  1321.                                              set("\x01",eval("\x01") + 615);
  1322.                                           }
  1323.                                           else if(eval("\x01") == 259)
  1324.                                           {
  1325.                                              set("\x01",eval("\x01") + 459);
  1326.                                           }
  1327.                                           else
  1328.                                           {
  1329.                                              if(eval("\x01") == 868)
  1330.                                              {
  1331.                                                 set("\x01",eval("\x01") - 170);
  1332.                                                 break loop0;
  1333.                                              }
  1334.                                              if(eval("\x01") == 837)
  1335.                                              {
  1336.                                                 set("\x01",eval("\x01") - 560);
  1337.                                                 gotoAndStop(1);
  1338.                                                 break loop0;
  1339.                                              }
  1340.                                              if(eval("\x01") == 698)
  1341.                                              {
  1342.                                                 set("\x01",eval("\x01") + 139);
  1343.                                              }
  1344.                                              else if(eval("\x01") == 304)
  1345.                                              {
  1346.                                                 set("\x01",eval("\x01") + 310);
  1347.                                                 ┬º┬ºpush(true);
  1348.                                              }
  1349.                                              else
  1350.                                              {
  1351.                                                 if(eval("\x01") == 579)
  1352.                                                 {
  1353.                                                    set("\x01",eval("\x01") - 320);
  1354.                                                    break loop0;
  1355.                                                 }
  1356.                                                 if(eval("\x01") == 718)
  1357.                                                 {
  1358.                                                    set("\x01",eval("\x01") + 96);
  1359.                                                    ┬º┬ºpush(true);
  1360.                                                 }
  1361.                                                 else if(eval("\x01") == 302)
  1362.                                                 {
  1363.                                                    set("\x01",eval("\x01") + 491);
  1364.                                                    ┬º┬ºpush(true);
  1365.                                                 }
  1366.                                                 else if(eval("\x01") == 94)
  1367.                                                 {
  1368.                                                    set("\x01",eval("\x01") + 208);
  1369.                                                 }
  1370.                                                 else if(eval("\x01") == 684)
  1371.                                                 {
  1372.                                                    set("\x01",eval("\x01") - 389);
  1373.                                                    if(┬º┬ºpop())
  1374.                                                    {
  1375.                                                       set("\x01",eval("\x01") + 260);
  1376.                                                    }
  1377.                                                 }
  1378.                                                 else if(eval("\x01") == 350)
  1379.                                                 {
  1380.                                                    set("\x01",eval("\x01") - 46);
  1381.                                                 }
  1382.                                                 else
  1383.                                                 {
  1384.                                                    if(eval("\x01") == 295)
  1385.                                                    {
  1386.                                                       set("\x01",eval("\x01") + 260);
  1387.                                                       break loop0;
  1388.                                                    }
  1389.                                                    if(eval("\x01") != 555)
  1390.                                                    {
  1391.                                                       break;
  1392.                                                    }
  1393.                                                    set("\x01",eval("\x01") - 253);
  1394.                                                 }
  1395.                                              }
  1396.                                           }
  1397.                                        }
  1398.                                     }
  1399.                                  }
  1400.                                  else
  1401.                                  {
  1402.                                     if(eval("\x01") == 298)
  1403.                                     {
  1404.                                        set("\x01",eval("\x01") - 57);
  1405.                                        continue;
  1406.                                     }
  1407.                                     if(eval("\x01") == 289)
  1408.                                     {
  1409.                                        set("\x01",eval("\x01") + 526);
  1410.                                        stop();
  1411.                                        var ┬º7{invalid_utf8=202}H┬º = ["╬¢g{invalid_utf8=141}\x12","{invalid_utf8=153}╧ê{invalid_utf8=143}AX{invalid_utf8=187}]","{invalid_utf8=144}{invalid_utf8=216}Z"];
  1412.                                        var ┬º{invalid_utf8=212}@[\f┬º = ┬º┬ºconstant(5);
  1413.                                        var ┬º┬ºconstant(6) = eval("{invalid_utf8=212}@[\f");
  1414.                                        var ┬º┬ºconstant(7) = null;
  1415.                                        eval(┬º┬ºconstant(8))[┬º┬ºconstant(9)][┬º┬ºconstant(10)] = ┬º┬ºconstant(11);
  1416.                                        break loop0;
  1417.                                     }
  1418.                                     if(eval("\x01") != 815)
  1419.                                     {
  1420.                                        break loop0;
  1421.                                     }
  1422.                                     set("\x01",eval("\x01") - 815);
  1423.                                  }
  1424.                               }
  1425.                            }
  1426.                            set("\x01",eval("\x01") + 445);
  1427.                            break loop0;
  1428.                         }
  1429.                         if(eval("\x01") != 411)
  1430.                         {
  1431.                            if(eval("\x01") == 578)
  1432.                            {
  1433.                               set("\x01",eval("\x01") - 260);
  1434.                               continue;
  1435.                            }
  1436.                            if(eval("\x01") == 983)
  1437.                            {
  1438.                               set("\x01",eval("\x01") - 737);
  1439.                               ┬º┬ºpush(true);
  1440.                               continue;
  1441.                            }
  1442.                            if(eval("\x01") == 318)
  1443.                            {
  1444.                               set("\x01",eval("\x01") - 66);
  1445.                               ┬º┬ºpush(true);
  1446.                               continue;
  1447.                            }
  1448.                            if(eval("\x01") == 161)
  1449.                            {
  1450.                               set("\x01",eval("\x01") + 335);
  1451.                               continue;
  1452.                            }
  1453.                            if(eval("\x01") == 141)
  1454.                            {
  1455.                               set("\x01",eval("\x01") + 470);
  1456.                               break loop0;
  1457.                            }
  1458.                            if(eval("\x01") == 860)
  1459.                            {
  1460.                               set("\x01",eval("\x01") - 496);
  1461.                               continue;
  1462.                            }
  1463.                         }
  1464.                         set("\x01",eval("\x01") - 98);
  1465.                         if(┬º┬ºpop())
  1466.                         {
  1467.                            set("\x01",eval("\x01") + 90);
  1468.                         }
  1469.                         continue;
  1470.                         if(eval("\x01") != 565)
  1471.                         {
  1472.                            if(eval("\x01") != 497)
  1473.                            {
  1474.                               if(eval("\x01") == 903)
  1475.                               {
  1476.                                  set("\x01",eval("\x01") - 492);
  1477.                                  ┬º┬ºpush(true);
  1478.                               }
  1479.                               else if(eval("\x01") == 951)
  1480.                               {
  1481.                                  set("\x01",eval("\x01") + 39);
  1482.                               }
  1483.                               else
  1484.                               {
  1485.                                  if(eval("\x01") == 507)
  1486.                                  {
  1487.                                     set("\x01",eval("\x01") - 130);
  1488.                                     play();
  1489.                                     break loop0;
  1490.                                  }
  1491.                                  if(eval("\x01") == 990)
  1492.                                  {
  1493.                                     set("\x01",eval("\x01") - 349);
  1494.                                     ┬º┬ºpush(true);
  1495.                                  }
  1496.                                  else
  1497.                                  {
  1498.                                     if(eval("\x01") == 499)
  1499.                                     {
  1500.                                        set("\x01",eval("\x01") - 70);
  1501.                                        ┬º┬ºpush(┬º┬ºpop() or length(┬º┬ºpop()));
  1502.                                        break loop0;
  1503.                                     }
  1504.                                     if(eval("\x01") == 92)
  1505.                                     {
  1506.                                        set("\x01",eval("\x01") + 794);
  1507.                                        ┬º┬ºpush(true);
  1508.                                     }
  1509.                                     else
  1510.                                     {
  1511.                                        if(eval("\x01") == 313)
  1512.                                        {
  1513.                                           set("\x01",eval("\x01") + 90);
  1514.                                           break loop0;
  1515.                                        }
  1516.                                        if(eval("\x01") == 133)
  1517.                                        {
  1518.                                           set("\x01",eval("\x01") + 231);
  1519.                                        }
  1520.                                        else
  1521.                                        {
  1522.                                           if(eval("\x01") == 597)
  1523.                                           {
  1524.                                              set("\x01",eval("\x01") - 331);
  1525.                                              break loop0;
  1526.                                           }
  1527.                                           if(eval("\x01") == 889)
  1528.                                           {
  1529.                                              set("\x01",eval("\x01") - 390);
  1530.                                              if(┬º┬ºpop())
  1531.                                              {
  1532.                                                 set("\x01",eval("\x01") - 70);
  1533.                                              }
  1534.                                           }
  1535.                                           else if(eval("\x01") == 368)
  1536.                                           {
  1537.                                              set("\x01",eval("\x01") + 615);
  1538.                                           }
  1539.                                           else if(eval("\x01") == 47)
  1540.                                           {
  1541.                                              set("\x01",eval("\x01") + 94);
  1542.                                              if(┬º┬ºpop())
  1543.                                              {
  1544.                                                 set("\x01",eval("\x01") + 470);
  1545.                                              }
  1546.                                           }
  1547.                                           else if(eval("\x01") == 101)
  1548.                                           {
  1549.                                              set("\x01",eval("\x01") + 882);
  1550.                                           }
  1551.                                           else if(eval("\x01") == 469)
  1552.                                           {
  1553.                                              set("\x01",eval("\x01") - 422);
  1554.                                              ┬º┬ºpush(true);
  1555.                                           }
  1556.                                           else if(eval("\x01") == 696)
  1557.                                           {
  1558.                                              set("\x01",eval("\x01") - 227);
  1559.                                           }
  1560.                                           else if(eval("\x01") == 854)
  1561.                                           {
  1562.                                              set("\x01",eval("\x01") - 347);
  1563.                                           }
  1564.                                           else if(eval("\x01") == 496)
  1565.                                           {
  1566.                                              set("\x01",eval("\x01") - 243);
  1567.                                              ┬º┬ºpush(true);
  1568.                                           }
  1569.                                           else if(eval("\x01") == 864)
  1570.                                           {
  1571.                                              set("\x01",eval("\x01") - 367);
  1572.                                              if(┬º┬ºpop())
  1573.                                              {
  1574.                                                 set("\x01",eval("\x01") + 68);
  1575.                                              }
  1576.                                           }
  1577.                                           else
  1578.                                           {
  1579.                                              if(eval("\x01") == 698)
  1580.                                              {
  1581.                                                 set("\x01",eval("\x01") - 2);
  1582.                                                 break loop0;
  1583.                                              }
  1584.                                              if(eval("\x01") == 567)
  1585.                                              {
  1586.                                                 set("\x01",eval("\x01") - 466);
  1587.                                                 ┬º┬ºpush(┬º┬ºpop() / (┬º┬ºpop() and ┬º┬ºpop()));
  1588.                                                 break loop0;
  1589.                                              }
  1590.                                              if(eval("\x01") == 266)
  1591.                                              {
  1592.                                                 set("\x01",eval("\x01") + 230);
  1593.                                              }
  1594.                                              else if(eval("\x01") == 429)
  1595.                                              {
  1596.                                                 set("\x01",eval("\x01") - 337);
  1597.                                              }
  1598.                                              else if(eval("\x01") == 581)
  1599.                                              {
  1600.                                                 set("\x01",eval("\x01") - 263);
  1601.                                              }
  1602.                                              else
  1603.                                              {
  1604.                                                 if(eval("\x01") != 611)
  1605.                                                 {
  1606.                                                    break;
  1607.                                                 }
  1608.                                                 set("\x01",eval("\x01") + 292);
  1609.                                              }
  1610.                                           }
  1611.                                        }
  1612.                                     }
  1613.                                  }
  1614.                               }
  1615.                               continue;
  1616.                            }
  1617.                            set("\x01",eval("\x01") + 68);
  1618.                         }
  1619.                         set("\x01",eval("\x01") - 58);
  1620.                         continue;
  1621.                         break loop0;
  1622.                      }
  1623.                      set("\x01",eval("\x01") - 504);
  1624.                      if(┬º┬ºpop())
  1625.                      {
  1626.                         set("\x01",eval("\x01") + 723);
  1627.                      }
  1628.                   }
  1629.                }
  1630.             }
  1631.          }
  1632.       }
  1633.    }
  1634.    ┬º┬ºgoto(addr338);
  1635. }
  1636.